{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3797e016",
   "metadata": {},
   "source": [
    "# Update Benchmark Notebook\n",
    "This notebook runs update benchmarks for SQLite, MongoDB, and ParquetDB across various row counts, then plots the update times.\n",
    "\n",
    "## Benchmark Details\n",
    "- **Data Generation:** 1,000,000 rows × 100 columns of integers (0–1,000,000), including an `id` column.\n",
    "- **Parquet Normalization (defaults):** row-group size 50,000–100,000 rows, max rows per file 10,000,000.\n",
    "\n",
    "## System Specifications\n",
    "- **Operating System:** Windows 10  \n",
    "- **Processor:** AMD Ryzen 7 3700X 8‑Core @ 3.6 MHz (8 cores, 16 logical processors)   \n",
    "- **Memory:** 128 GB DDR4‑3600 MHz (4×32 GB DIMMs) \n",
    "- **Storage**: SATA HDD 2TB (Model: ST2000DM008-2FR102)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d7e2148",
   "metadata": {},
   "source": [
    "## 1. Setup\n",
    "Import libraries and define directories and parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e324590",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install parquetdb\n",
    "!pip install pymongo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "66be9f97",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import random\n",
    "import shutil\n",
    "import sqlite3\n",
    "import pandas as pd\n",
    "from pymongo import MongoClient, UpdateOne\n",
    "import pyarrow.compute as pc\n",
    "from parquetdb import ParquetDB, config\n",
    "from parquetdb.utils import general_utils\n",
    "\n",
    "# Directories\n",
    "bench_dir = os.path.join(config.data_dir, 'benchmarks')\n",
    "sqlite_dir = os.path.join(bench_dir, 'sqlite')\n",
    "mongo_dir  = os.path.join(bench_dir, 'mongodb')\n",
    "pq_dir     = os.path.join(bench_dir, 'parquetdb')\n",
    "for d in (sqlite_dir, mongo_dir, pq_dir): \n",
    "    os.makedirs(d, exist_ok=True)\n",
    "\n",
    "row_counts = [1, 10, 100, 1000, 10000, 100000, 1000000]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf798ad6",
   "metadata": {},
   "source": [
    "## 2. SQLite Update Benchmark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "52e96829",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SQLite update 1 rows: 0.1146s\n",
      "SQLite update 10 rows: 0.1570s\n",
      "SQLite update 100 rows: 0.1992s\n",
      "SQLite update 1000 rows: 0.1277s\n",
      "SQLite update 10000 rows: 0.6371s\n",
      "SQLite update 100000 rows: 6.4969s\n",
      "SQLite update 1000000 rows: 70.6703s\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>n_rows</th>\n",
       "      <th>update_times</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.114572</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>0.157016</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100</td>\n",
       "      <td>0.199238</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000</td>\n",
       "      <td>0.127741</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10000</td>\n",
       "      <td>0.637138</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   n_rows  update_times\n",
       "0       1      0.114572\n",
       "1      10      0.157016\n",
       "2     100      0.199238\n",
       "3    1000      0.127741\n",
       "4   10000      0.637138"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def generate_data_sqlite(num_rows, n_columns=100):\n",
    "    data = []\n",
    "    for i in range(num_rows):\n",
    "        row = (i,) + tuple(random.randint(0, 1000000) for _ in range(n_columns - 1))\n",
    "        data.append(row)\n",
    "    return data\n",
    "\n",
    "def remove_db_file(db_name):\n",
    "    if os.path.exists(db_name): os.remove(db_name)\n",
    "\n",
    "def benchmark_update_sqlite(num_rows, db_name):\n",
    "    update_data = generate_data_sqlite(num_rows)\n",
    "    update_values = [row[1:] + (row[0],) for row in update_data]\n",
    "    conn = sqlite3.connect(db_name)\n",
    "    update_query = (\n",
    "        'UPDATE test_table SET ' + ', '.join(f'col{ i }=?' for i in range(1,100)) + ' WHERE col0=?'\n",
    "    )\n",
    "    start = time.time()\n",
    "    cursor = conn.cursor()\n",
    "    cursor.executemany(update_query, update_values)\n",
    "    conn.commit()\n",
    "    conn.close()\n",
    "    return time.time() - start\n",
    "\n",
    "# Initial setup\n",
    "db_file = os.path.join(sqlite_dir, 'benchmark.db')\n",
    "remove_db_file(db_file)\n",
    "data = generate_data_sqlite(1000000)\n",
    "conn = sqlite3.connect(db_file)\n",
    "cursor = conn.cursor()\n",
    "cols = ', '.join(f'col{i} INTEGER' for i in range(100))\n",
    "cursor.execute(f'CREATE TABLE test_table ({cols})')\n",
    "placeholders = ', '.join('?' for _ in range(100))\n",
    "conn.execute('PRAGMA synchronous = OFF')\n",
    "conn.execute('PRAGMA journal_mode = MEMORY')\n",
    "start = time.time()\n",
    "cursor.executemany(f'INSERT INTO test_table VALUES ({placeholders})', data)\n",
    "conn.commit()\n",
    "insert_time = time.time() - start\n",
    "conn.close()\n",
    "data = None\n",
    "conn = sqlite3.connect(db_file)\n",
    "conn.execute('CREATE INDEX idx_col0 ON test_table(col0)')\n",
    "conn.commit(); conn.close()\n",
    "\n",
    "# Run update benchmarks\n",
    "results_sql = {'n_rows': [], 'update_times': []}\n",
    "for n in row_counts:\n",
    "    ut = benchmark_update_sqlite(n, db_file)\n",
    "    results_sql['n_rows'].append(n)\n",
    "    results_sql['update_times'].append(ut)\n",
    "    print(f'SQLite update {n} rows: {ut:.4f}s')\n",
    "df_sql = pd.DataFrame(results_sql)\n",
    "df_sql.to_csv(os.path.join(sqlite_dir, 'sqlite_update_benchmark.csv'), index=False)\n",
    "df_sql.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9909635",
   "metadata": {},
   "source": [
    "## 3. MongoDB Update Benchmark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "35b63638",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MongoDB update 1 rows: 0.0060s\n",
      "MongoDB update 10 rows: 0.0040s\n",
      "MongoDB update 100 rows: 0.0320s\n",
      "MongoDB update 1000 rows: 0.3640s\n",
      "MongoDB update 10000 rows: 3.1343s\n",
      "MongoDB update 100000 rows: 31.9809s\n",
      "MongoDB update 1000000 rows: 324.0146s\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>n_rows</th>\n",
       "      <th>update_times</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.006001</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>0.004001</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100</td>\n",
       "      <td>0.032002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000</td>\n",
       "      <td>0.364002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10000</td>\n",
       "      <td>3.134346</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   n_rows  update_times\n",
       "0       1      0.006001\n",
       "1      10      0.004001\n",
       "2     100      0.032002\n",
       "3    1000      0.364002\n",
       "4   10000      3.134346"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def generate_data_mongo(num_rows, n_columns=100):\n",
    "    data = []\n",
    "    for i in range(num_rows):\n",
    "        doc = {'id': i}\n",
    "        doc.update({f'col{j}': random.randint(0,1000000) for j in range(n_columns)})\n",
    "        data.append(doc)\n",
    "    return data\n",
    "\n",
    "def remove_db(client, db_name): client.drop_database(db_name)\n",
    "\n",
    "def benchmark_update_mongo(num_rows, client, db_name='benchmark'):\n",
    "    coll = client[db_name].test_collection\n",
    "    update_data = generate_data_mongo(num_rows)\n",
    "    ops = [UpdateOne({'id': d['id']}, {'$set': {k:v for k,v in d.items() if k!='id'}}) for d in update_data]\n",
    "    start = time.time()\n",
    "    coll.bulk_write(ops)\n",
    "    return time.time() - start\n",
    "\n",
    "# Initial setup\n",
    "client = MongoClient('mongodb://localhost:27017/')\n",
    "remove_db(client, 'benchmark')\n",
    "data = generate_data_mongo(1000000)\n",
    "coll = client.benchmark.test_collection\n",
    "start = time.time(); coll.insert_many(data); insert_time = time.time() - start\n",
    "coll.create_index('id', unique=True)\n",
    "data = None\n",
    "\n",
    "# Run update benchmarks\n",
    "results_mg = {'n_rows': [], 'update_times': []}\n",
    "for n in row_counts:\n",
    "    ut = benchmark_update_mongo(n, client)\n",
    "    results_mg['n_rows'].append(n)\n",
    "    results_mg['update_times'].append(ut)\n",
    "    print(f'MongoDB update {n} rows: {ut:.4f}s')\n",
    "df_mg = pd.DataFrame(results_mg)\n",
    "df_mg.to_csv(os.path.join(mongo_dir, 'mongodb_update_benchmark.csv'), index=False)\n",
    "client.close()\n",
    "df_mg.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39624668",
   "metadata": {},
   "source": [
    "## 4. ParquetDB Update Benchmark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d29af608",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 2025-04-19 14:00:43 - parquetdb.core.parquetdb[205][__init__] - Initializing ParquetDB with db_path: Z:\\data\\parquetdb\\data\\benchmarks\\parquetdb\\BenchmarkDB\n",
      "[INFO] 2025-04-19 14:00:43 - parquetdb.core.parquetdb[207][__init__] - verbose: 1\n",
      "ParquetDB update 1 rows: 9.0115s\n",
      "ParquetDB update 10 rows: 8.2933s\n",
      "ParquetDB update 100 rows: 8.2528s\n",
      "ParquetDB update 1000 rows: 8.1811s\n",
      "ParquetDB update 10000 rows: 9.6150s\n",
      "ParquetDB update 100000 rows: 10.6442s\n",
      "ParquetDB update 1000000 rows: 27.3471s\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>n_rows</th>\n",
       "      <th>update_times</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>9.011520</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>8.293251</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100</td>\n",
       "      <td>8.252841</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000</td>\n",
       "      <td>8.181065</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10000</td>\n",
       "      <td>9.614958</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   n_rows  update_times\n",
       "0       1      9.011520\n",
       "1      10      8.293251\n",
       "2     100      8.252841\n",
       "3    1000      8.181065\n",
       "4   10000      9.614958"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db_path = os.path.join(pq_dir, 'BenchmarkDB')\n",
    "if os.path.exists(db_path): shutil.rmtree(db_path)\n",
    "db = ParquetDB(db_path)\n",
    "data = general_utils.generate_pydict_data(n_rows=1000000, min_value=0, max_value=1000000)\n",
    "db.create(data); data=None\n",
    "\n",
    "def benchmark_update_pq(num_rows):\n",
    "    update_data = general_utils.generate_pylist_update_data(n_rows=num_rows, min_value=0, max_value=1000000)\n",
    "    start = time.time(); db.update(update_data); return time.time() - start\n",
    "\n",
    "results_pq = {'n_rows': [], 'update_times': []}\n",
    "for n in row_counts:\n",
    "    ut = benchmark_update_pq(n)\n",
    "    results_pq['n_rows'].append(n)\n",
    "    results_pq['update_times'].append(ut)\n",
    "    print(f'ParquetDB update {n} rows: {ut:.4f}s')\n",
    "df_pq = pd.DataFrame(results_pq)\n",
    "df_pq.to_csv(os.path.join(pq_dir, 'parquetdb_update_benchmark.csv'), index=False)\n",
    "df_pq.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3004728b",
   "metadata": {},
   "source": [
    "## 5. Load and Preview Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c11a671d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(   n_rows  update_times\n",
       " 0       1      0.114572\n",
       " 1      10      0.157016\n",
       " 2     100      0.199238\n",
       " 3    1000      0.127741\n",
       " 4   10000      0.637138,\n",
       "    n_rows  update_times\n",
       " 0       1      0.006001\n",
       " 1      10      0.004001\n",
       " 2     100      0.032002\n",
       " 3    1000      0.364002\n",
       " 4   10000      3.134346,\n",
       "    n_rows  update_times\n",
       " 0       1      9.011520\n",
       " 1      10      8.293251\n",
       " 2     100      8.252841\n",
       " 3    1000      8.181065\n",
       " 4   10000      9.614958)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_sql = pd.read_csv(os.path.join(sqlite_dir, \"sqlite_update_benchmark.csv\"))\n",
    "df_mg = pd.read_csv(os.path.join(mongo_dir, \"mongodb_update_benchmark.csv\"))\n",
    "df_pq    = pd.read_csv(os.path.join(pq_dir, \"parquetdb_update_benchmark.csv\"))\n",
    "\n",
    "df_sql.head(), df_mg.head(), df_pq.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b0b2532",
   "metadata": {},
   "source": [
    "## 6. Plot Update Times\n",
    "\n",
    "Plot update times vs. number of rows for each backend with inset log–log."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1bc98e29",
   "metadata": {
    "tags": [
     "nbsphinx-thumbnail"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\lllang\\AppData\\Local\\Temp\\ipykernel_48688\\1553411592.py:101: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
      "  plt.tight_layout()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n",
    "\n",
    "n_rows = df_pq[\"n_rows\"]\n",
    "\n",
    "colors = {'sqlite':'#e52207','mongodb':'#e5a000','parquetdb':'#59b9de'}\n",
    "markers = {'sqlite':'o','mongodb':'o','parquetdb':'o'}\n",
    "fill = {'sqlite':'full','mongodb':'full','parquetdb':'full'}\n",
    "\n",
    "fig, ax1 = plt.subplots(figsize=(10,6))\n",
    "\n",
    "ax1.plot(n_rows, \n",
    "        df_sql['update_times'], \n",
    "        label=\"sqlite\",\n",
    "        color=colors[\"sqlite\"], \n",
    "        linestyle='solid',\n",
    "        marker=markers[\"sqlite\"], \n",
    "        fillstyle=fill[\"sqlite\"])\n",
    "\n",
    "ax1.plot(n_rows, \n",
    "        df_mg['update_times'], \n",
    "        label=\"mongodb\",\n",
    "        color=colors[\"mongodb\"], \n",
    "        linestyle='solid',\n",
    "        marker=markers[\"mongodb\"], \n",
    "        fillstyle=fill[\"mongodb\"])\n",
    "\n",
    "ax1.plot(n_rows, \n",
    "        df_pq['update_times'], \n",
    "        label=\"parquetdb\",\n",
    "        color=colors[\"parquetdb\"], \n",
    "        linestyle='solid',\n",
    "        marker=markers[\"parquetdb\"], \n",
    "        fillstyle=fill[\"parquetdb\"])\n",
    "\n",
    "ax1.set_xlabel('Number of Rows')\n",
    "ax1.set_ylabel('Update Times (s)')\n",
    "ax1.grid(True)\n",
    "\n",
    "ax_inset = inset_axes(ax1, width='36%', height='36%', loc='upper left',\n",
    "                  bbox_to_anchor=(0.05,-0.03,1,1), bbox_transform=ax1.transAxes)\n",
    "\n",
    "ax_inset.plot(n_rows, \n",
    "        df_sql['update_times'],\n",
    "        color=colors[\"sqlite\"], \n",
    "        linestyle='solid', \n",
    "        marker=markers[\"sqlite\"], \n",
    "        fillstyle=fill[\"sqlite\"])\n",
    "ax_inset.plot(n_rows, \n",
    "        df_mg['update_times'],\n",
    "        color=colors[\"mongodb\"], \n",
    "        linestyle='solid', \n",
    "        marker=markers[\"mongodb\"], \n",
    "        fillstyle=fill[\"mongodb\"])\n",
    "ax_inset.plot(n_rows, \n",
    "        df_pq['update_times'],\n",
    "        color=colors[\"parquetdb\"], \n",
    "        linestyle='solid', \n",
    "        marker=markers[\"parquetdb\"], \n",
    "        fillstyle=fill[\"parquetdb\"])\n",
    "\n",
    "ax_inset.grid(True)\n",
    "\n",
    "\n",
    "# Set log scale for both axes in the inset\n",
    "ax_inset.set_xscale(\"log\")\n",
    "ax_inset.set_yscale(\"log\")\n",
    "\n",
    "# Set labels for inset plot\n",
    "ax_inset.set_xlabel(\"Number of Rows (log)\", fontsize=8)\n",
    "ax_inset.set_ylabel(\"Update Time (log)\", fontsize=8, labelpad=-2)\n",
    "# ax_inset2.set_ylabel('Read Time (log)', fontsize=8)\n",
    "\n",
    "nticks = 9\n",
    "maj_loc = ticker.LogLocator(numticks=nticks)\n",
    "min_loc = ticker.LogLocator(subs=\"all\", numticks=nticks)\n",
    "ax_inset.xaxis.set_major_locator(maj_loc)\n",
    "ax_inset.xaxis.set_minor_locator(min_loc)\n",
    "\n",
    "# Set the same linestyle and make the spine thicker for visibility\n",
    "ax_inset.spines[\"left\"].set_linestyle(\"solid\")\n",
    "ax_inset.spines[\"left\"].set_linewidth(2.5)  # Increase the line width for visibility\n",
    "\n",
    "# Hide the right spine on ax1 and left spine on ax2 to prevent overlap\n",
    "# ax_inset.spines['right'].set_visible(False)\n",
    "\n",
    "ax_inset.tick_params(\n",
    "axis=\"both\", which=\"major\", length=6, width=1.5, direction=\"out\"\n",
    ")\n",
    "ax_inset.tick_params(axis=\"x\", which=\"minor\", length=3, width=1, direction=\"out\")\n",
    "ax_inset.tick_params(axis=\"y\", which=\"minor\", length=3, width=1, direction=\"out\")\n",
    "\n",
    "lines_1, labels_1 = ax1.get_legend_handles_labels()\n",
    "\n",
    "ax1.legend(lines_1, labels_1, loc=\"upper center\", bbox_to_anchor=(0.12, 0, 1, 1))\n",
    "\n",
    "ax1.set_title(\n",
    "\"Update Benchmark: \\n SQLite, MongoDB, and ParquetDB with 100 integer columns\"\n",
    ")\n",
    "plt.tight_layout()\n",
    "plt.savefig(os.path.join(bench_dir,\"update-into-constant-rows_benchmark.pdf\"))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69d8c292",
   "metadata": {},
   "source": [
    "## 6. Dicussion\n",
    "\n",
    "1. **Low‑volume vs. bulk updates**  \n",
    "   - **SQLite** and **MongoDB** shine for small update sets (≤ 100 rows), with per‑row C‑level operations incurring only sub‑second overhead.  \n",
    "   - **ParquetDB** pays a hefty **~8 s baseline** even for a single row, because it must rewrite an entire row‑group file on each update.\n",
    "\n",
    "2. **Scaling behavior**  \n",
    "   - **SQLite** & **MongoDB** scale **linearly**: ~0.1 s at 10 K → ~30 s at 100 K → ~70 s at 1 M rows.  \n",
    "   - **ParquetDB** is **flat** at ~8 s up to ~100 K rows (one row‑group), then climbs **sub‑linearly** to ~15 s at 100 K → ~25 s at 1 M.\n",
    "\n",
    "3. **Row‑group architecture drives performance**  \n",
    "   - Default row‑group size (50 K–100 K rows) means ParquetDB touches **only one group** for small/medium updates, so time is constant.  \n",
    "   - At 1 M rows (≈ 10 groups), ParquetDB rewrites 10 groups in **parallel**, leveraging multithreading and columnar skips, yielding **better throughput** than both row‑stores.\n",
    "\n",
    "4. **Key takeaway**  \n",
    "   - ParquetDB’s **group‑level rewrite overhead** makes it **inefficient** for tiny, ad‑hoc updates, but its **columnar, parallel design** gives it a decisive edge on **large‑scale** batch updates.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "parquetdb_dev",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.20"
  },
  "nbsphinx": {
   "execute": "never"
  },
  "nbsphinx-thumbnail": {
   "tooltip": "In this example, we benchmark the performance for updates into a constant number of rows in ParquetDB vs. SQLite and MongoDB."
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
